package business

import (
	"errors"
	"fmt"
	"github.com/flipped-aurora/gin-vue-admin/server/global"
	"github.com/flipped-aurora/gin-vue-admin/server/model/business"
	businessReq "github.com/flipped-aurora/gin-vue-admin/server/model/business/request"
	"github.com/flipped-aurora/gin-vue-admin/server/model/common/request"
	"github.com/flipped-aurora/gin-vue-admin/server/utils"
	"gorm.io/gorm"
	"strings"
	"time"
)

type QuestionnaireService struct {
}

// CreateQuestionnaire 创建问卷记录
// Author [piexlmax](https://github.com/piexlmax)

//	func (questionnaireService *QuestionnaireService) CreateQuestionnaire(questionnaireCreate *businessReq.QuestionnaireCreate) error {
//		db := global.GVA_DB
//		//生成uuid
//		questionnaireCreate.Questionnaire.Uuid = utils.GetMD5Encode(fmt.Sprint(time.Now().UnixNano()) + utils.RandStr(6))
//		questionnaire := questionnaireCreate.Questionnaire
//		err := db.Model(&business.Questionnaire{}).Create(&questionnaire).Error
//		if err != nil {
//			return err
//		}
//		//err := db.Transaction(func(tx *gorm.DB) error {
//		//	err := tx.Model(&business.Questionnaire{}).Create(&questionnaire).Error
//		//	if err != nil {
//		//		return err
//		//	}
//		//	questionnaireId := questionnaire.ID
//		//	questionnaireUuid := questionnaire.Uuid
//		//	//定义两个集合
//		//	var questionList []*business.Question
//		//	var optionList []*business.Option
//		//	for _, qv := range questionnaireCreate.QuestionList {
//		//		qv.QuestionnaireId = questionnaireId
//		//		qv.QuestionnaireUuid = questionnaireUuid
//		//		questionList = append(questionList, &qv.Question)
//		//		for _, ov := range qv.OptionList {
//		//			ov.QuestionnaireId = questionnaireId
//		//			ov.QuestionnaireUuid = questionnaireUuid
//		//			ov.QuestionSort = qv.Sort
//		//			optionList = append(optionList, &ov)
//		//		}
//		//	}
//		//	err = tx.Model(&business.Question{}).Create(&questionList).Error
//		//	if err != nil {
//		//		return err
//		//	}
//		//	err = tx.Model(&business.Option{}).Create(&optionList).Error
//		//	if err != nil {
//		//		return err
//		//	}
//		//	return nil
//		//})
//
//		return err
//	}
func (questionnaireService *QuestionnaireService) CreateQuestionnaireByEnterprise(questionnaire *business.Questionnaire) error {
	db := global.GVA_DB
	//生成uuid
	questionnaire.Uuid = utils.GetMD5Encode(fmt.Sprint(time.Now().UnixNano()) + utils.RandStr(6))
	markList := utils.String2Int(strings.Split(questionnaire.MarkListInfo, ","))
	err := db.Transaction(func(tx *gorm.DB) error {
		err := tx.Model(&business.Questionnaire{}).Create(&questionnaire).Error
		if err != nil {
			return err
		}
		//查询分类信息
		classifyList, err := classifyService.GetClassifyListByUserId(questionnaire.UserId)
		if err != nil {
			return err
		}
		//查询企业信息
		enterpriseList, err := enterpriseService.GetEnterpriseByUserId(questionnaire.UserId)
		if err != nil {
			return err
		}
		var questionList []business.Question
		var optionList []business.Option
		for _, cv := range classifyList {
			for ek, ev := range enterpriseList {
				questionList = append(questionList, business.Question{
					QuestionnaireId:   questionnaire.ID,
					QuestionnaireUuid: questionnaire.Uuid,
					Text:              ev.Name,
					Sort:              int32(ek + 1),
					QType:             0,
					Msg:               ev.Msg,
					QuestionType:      cv.Name,
				})
				for mk, mv := range markList {
					fmt.Println(mk + 1)
					optionList = append(optionList, business.Option{
						QuestionnaireId:   questionnaire.ID,
						QuestionnaireUuid: questionnaire.Uuid,
						QuestionSort:      int32(ek + 1),
						Mark:              int32(mv),
						Sort:              int32(mk + 1),
					})
				}
			}
			err = tx.Model(&business.Question{}).Create(&questionList).Error
			if err != nil {
				return err
			}
			err = tx.Model(&business.Option{}).Create(&optionList).Error
			if err != nil {
				return err
			}
			//创建问卷限制
			questionnaireSetting := business.QuestionnaireSetting{
				GVA_MODEL:         global.GVA_MODEL{},
				QuestionnaireUuid: questionnaire.Uuid,
			}
			err = tx.Create(&questionnaireSetting).Error
			if err != nil {
				return err
			}
		}
		return nil
	})

	return err
}

// DeleteQuestionnaire 删除问卷记录
// Author [piexlmax](https://github.com/piexlmax)
func (questionnaireService *QuestionnaireService) DeleteQuestionnaire(questionnaire business.Questionnaire) (err error) {
	db := global.GVA_DB
	if questionnaire.UserId != 0 {
		db.Where("user_id = ?", questionnaire.UserId)
	}
	err = db.Delete(&questionnaire).Error
	return err
}

// DeleteQuestionnaireByIds 批量删除问卷记录
// Author [piexlmax](https://github.com/piexlmax)
func (questionnaireService *QuestionnaireService) DeleteQuestionnaireByIds(ids request.IdsReq, userId uint) (err error) {
	db := global.GVA_DB
	if userId != 0 {
		db.Where("user_id = ?", userId)
	}
	err = db.Delete(&[]business.Questionnaire{}, "id in ?", ids.Ids).Error
	return err
}

// UpdateQuestionnaire 更新问卷记录
// Author [piexlmax](https://github.com/piexlmax)
func (questionnaireService *QuestionnaireService) UpdateQuestionnaire(questionnaire business.Questionnaire) (err error) {
	db := global.GVA_DB
	var questionnaireInfo business.Questionnaire
	db = db.Where("uuid = ? ", questionnaire.Uuid)
	if questionnaire.UserId != 0 {
		db = db.Where("user_id = ? ", questionnaire.UserId)
	}
	err = db.First(&questionnaireInfo).Error
	if questionnaireInfo.ID == 0 {
		return errors.New("没有发现该问卷")
	}
	db = global.GVA_DB
	MarkList := utils.String2Int(strings.Split(questionnaire.MarkListInfo, ","))
	err = db.Transaction(func(tx *gorm.DB) error {
		questionnaireMap := map[string]interface{}{
			"name":           questionnaire.Name,
			"end_time":       questionnaire.EndTime,
			"end_number":     questionnaire.EndNumber,
			"st":             questionnaire.St,
			"mark_list_info": questionnaire.MarkListInfo,
		}
		err = tx.Model(&business.Questionnaire{}).Where("id = ?", questionnaire.ID).Updates(&questionnaireMap).Error
		if err != nil {
			return err
		}
		if questionnaire.MarkListInfo == questionnaireInfo.MarkListInfo {
			return nil
		}
		if (questionnaire.MarkListInfo != questionnaireInfo.MarkListInfo && questionnaire.St == 1) && questionnaire.Number > 0 {
			return errors.New("问卷已经启动或者已有人开始答卷，不能更改分数信息")
		}
		//删除之前的信息
		err = tx.Model(&business.Question{}).Where("questionnaire_id = ?", questionnaireInfo.ID).Unscoped().Delete(&business.Question{}).Error
		if err != nil {
			return err
		}
		err = tx.Model(&business.Option{}).Where("questionnaire_id = ?", questionnaireInfo.ID).Unscoped().Delete(&business.Option{}).Error
		if err != nil {
			return err
		}
		//查询分类信息
		classifyList, err := classifyService.GetClassifyListByUserId(questionnaire.UserId)
		if err != nil {
			return err
		}
		//查询企业信息
		enterpriseList, err := enterpriseService.GetEnterpriseByUserId(questionnaire.UserId)
		if err != nil {
			return err
		}
		var questionList []business.Question
		var optionList []business.Option
		for _, cv := range classifyList {
			for ek, ev := range enterpriseList {
				questionList = append(questionList, business.Question{
					QuestionnaireId:   questionnaire.ID,
					QuestionnaireUuid: questionnaire.Uuid,
					Text:              ev.Name,
					Sort:              int32(ek + 1),
					QType:             0,
					Msg:               ev.Msg,
					QuestionType:      cv.Name,
				})
				for mk, mv := range MarkList {
					optionList = append(optionList, business.Option{
						QuestionnaireId:   questionnaire.ID,
						QuestionnaireUuid: questionnaire.Uuid,
						QuestionSort:      int32(ek + 1),
						Mark:              int32(mv),
						Sort:              int32(mk + 1),
					})
				}
			}
			err = tx.Model(&business.Question{}).Create(&questionList).Error
			if err != nil {
				return err
			}
			err = tx.Model(&business.Option{}).Create(&optionList).Error
			if err != nil {
				return err
			}
		}
		return nil
	})

	return err

}

// GetQuestionnaire 根据id获取问卷记录
// Author [piexlmax](https://github.com/piexlmax)
func (questionnaireService *QuestionnaireService) GetQuestionnaire(id uint, userId uint) (questionnaire business.Questionnaire, err error) {
	db := global.GVA_DB.Where("id = ? ", id)
	if userId != 0 {
		db = db.Where("user_id = ? ", userId)
	}
	err = db.First(&questionnaire).Error
	return
}

func (questionnaireService *QuestionnaireService) GetQuestionnaireByUuid(uuid string, userId uint) (questionnaire business.Questionnaire, err error) {
	db := global.GVA_DB.Where("uuid = ? ", uuid)
	if userId != 0 {
		db = db.Where("user_id = ? ", userId)
	}
	err = db.First(&questionnaire).Error
	if err == gorm.ErrRecordNotFound {
		return questionnaire, nil
	}
	return
}

// GetQuestionnaireInfoList 分页获取问卷记录
// Author [piexlmax](https://github.com/piexlmax)
func (questionnaireService *QuestionnaireService) GetQuestionnaireInfoList(info businessReq.QuestionnaireSearch) (list []business.Questionnaire, total int64, err error) {
	limit := info.PageSize
	offset := info.PageSize * (info.Page - 1)
	// 创建db
	db := global.GVA_DB.Model(&business.Questionnaire{})
	var questionnaires []business.Questionnaire
	// 如果有条件搜索 下方会自动创建搜索语句
	if info.StartCreatedAt != nil && info.EndCreatedAt != nil {
		db = db.Where("created_at BETWEEN ? AND ?", info.StartCreatedAt, info.EndCreatedAt)
	}
	if info.Name != "" {
		db = db.Where("name LIKE ?", "%"+info.Name+"%")
	}
	if info.Uuid != "" {
		db = db.Where("uuid = ?", "%"+info.Uuid+"%")
	}
	if info.StartEndTime != nil && info.EndEndTime != nil {
		db = db.Where("end_time BETWEEN ? AND ? ", info.StartEndTime, info.EndEndTime)
	}
	if info.UserId != 0 {
		db = db.Where("user_id = ?", info.UserId)
	}
	err = db.Count(&total).Error
	if err != nil {
		return
	}

	if limit != 0 {
		db = db.Limit(limit).Offset(offset)
	}

	err = db.Find(&questionnaires).Error
	return questionnaires, total, err
}
